<article id="wikiArticle">
<p></p> <div class="prevnext" style="text-align: right;">
<p><a href="Guide/Introduction" style="float: left;">« 上一页</a><a href="Guide/Control_flow_and_error_handling">下一页  »</a></p>
</div><p></p>
<p class="summary">本章讨论 JavaScript 的基本语法，变量声明，数据类型 和 字面量。</p>
<h2 id="基础">基础</h2>
<p>JavaScript 借鉴了 Java 的大部分语法，但同时也受到 <em>Awk，Perl </em>和 <em>Python</em>的影响。 </p>
<p>JavaScript 是<strong>区分大小写</strong>的，并使用 <strong>Unicode </strong>字符集。举个例子，可以将单词 Früh （在德语中意思是“早”）用作变量名。</p>
<pre><code>var Früh = "foobar";</code></code></pre>
<p>但是，由于 JavaScript 是大小写敏感的，因此变量 <code>früh</code> 和 <code>Früh</code> 则是两个不同的变量。</p>
<p>在 JavaScript 中，指令被称为语句  <a class="glossaryLink" href="/en-US/docs/Glossary/Statement" title="Statement: In a computer programming language, a statement is a line of code commanding a task. Every program consists of a sequence of statements.">Statement</a>，并用分号（;）进行分隔。</p>
<p>如果一条语句独占一行的话，那么分号是可以省略的。（译者注：并不建议这么做。）但如果一行中有多条语句，那么这些语句必须以分号分开。 ECMAScript 规定了在语句的末尾自动插入分号（<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">ASI</a>）。（如果想要了解更多信息，请参阅 JavaScript <a href="Reference/Lexical_grammar">词法语法</a> 。）虽然不是必需的，但是在一条语句的末尾加上分号是一个很好的习惯。这个习惯可以大大减少代码中产生 bug 的可能性。</p>
<p> Javascript 源码从左往右被扫描并转换成一系列由 token 、控制字符、行终止符、注释和空白字符组成的输入元素。空白字符指的是空格、制表符和换行符等。</p>
<h2 id="注释">注释</h2>
<p><strong>Javascript 注释</strong>的语法和 C++ 或许多其他语言类似：</p>
<pre><code  class="language-javascript">// 单行注释

/* 这是一个更长的,
   多行注释
*/

/* 然而, 你不能, /* 嵌套注释 */ <strong>语法错误</strong> */</code></pre>
<p>在代码执行过程中，注释将被自动跳过（不执行）。</p>
<h2 id="声明">声明</h2>
<p>JavaScript有三种声明方式。</p>
<dl>
<dt><a href="Reference/Statements/var" title="var 声明语句声明一个变量，并可选地将其初始化为一个值。"><code>var</code></a></dt>
<dd>声明一个变量，可选初始化一个值。</dd>
<dt><a href="Reference/Statements/let" title="let允许你声明一个作用域被限制在块级中的变量、语句或者表达式。与var关键字不同的是，var声明的变量只能是全局或者整个函数块的。"><code>let</code></a></dt>
<dd>声明一个块作用域的局部变量，可选初始化一个值。</dd>
<dt><a href="Reference/Statements/const" title="常量是块级作用域，很像使用 let 语句定义的变量。常量的值不能通过重新赋值来改变，并且不能重新声明。"><code>const</code></a></dt>
<dd>声明一个块作用域的只读常量。</dd>
</dl>
<h3 id="变量">变量</h3>
<p>在应用程序中，使用变量来作为值的符号名。变量的名字又叫做<a class="glossaryLink" href="/en-US/docs/Glossary/Identifier" title="标识符: A sequence of characters in the code that identifies a variable, function, or property.">标识符</a>，其需要遵守一定的规则。</p>
<p>一个 JavaScript 标识符必须以字母、下划线（_）或者美元符号（$）开头；后续的字符也可以是数字（0-9）。因为 JavaScript 语言是区分大小写的，所以字母可以是从“A”到“Z”的大写字母和从“a”到“z”的小写字母。</p>
<p>你可以使用大部分 ISO 8859-1 或 Unicode 编码的字符作标识符，例如 å 和 ü（详情可查看<a class="external" href="https://mathiasbynens.be/notes/javascript-identifiers-es6" rel="noopener">这篇博客文章</a>）。你也可以使用 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">Unicode 转义字符</a> 作标识符。</p>
<p>合法的标识符示例：<code>Number_hits</code>，<code>temp99</code>，<code>$credit</code> 和 <code>_name</code>。</p>
<h3 id="声明变量">声明变量</h3>
<p>你可以用以下三种方式声明变量：</p>
<ul>
<li>使用关键词 <code>var</code> 。例如 <code>var x = 42</code>。这个语法可以用来声明局部变量和全局变量。</li>
<li>直接赋值。例如<code>x = 42</code>。在函数外使用这种形式赋值，会产生一个全局变量。在严格模式下会产生错误。因此你不应该使用这种方式来声明变量。</li>
<li>使用关键词 <code>let</code> 。例如 <code>let y = 13</code>。这个语法可以用来声明块作用域的局部变量。參考下方<a href="https://developer.mozilla.orgGuide/Grammar_and_types#变量的作用域">变量的作用域(Variable scope)</a> 。</li>
</ul>
<h3 id="变量求值">变量求值</h3>
<p>用 <code>var</code> 或 <code>let</code> 语句声明的变量，如果没有赋初始值，则其值为 <code>undefined</code> 。</p>
<p>如果访问一个未声明的变量会导致抛出一个引用错误（ReferenceError）异常：</p>
<pre><code  class="language-javascript">var a;
console.log("The value of a is " + a); // a 的值是 undefined

console.log("The value of b is " + b);// b 的值是 undefined 
var b;
// 在你阅读下面的‘变量生命提升’前你可能会疑惑

console.log("The value of c is " + c); // 未捕获的引用错误： c 未被定义

let x;
console.log("The value of x is " + x); // x 的值是 undefined

console.log("The value of y is " + y);// 未捕获的引用错误： y 未被定义
let y;</code></pre>
<p>你可以使用 <code>undefined</code> 来判断一个变量是否已赋值。在以下的代码中，变量<code>input</code>未被赋值，因此 <code><a class="new" href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Statements/if...else" rel="nofollow" title="zh-CN/docs/JavaScript/Reference/Statements/if...else">if</a></code> 条件语句的求值结果是 <code>true</code> 。</p>
<pre><code  class="language-javascript">var input;
if(input === undefined){
  doThis();
} else {
  doThat();
}
</code></pre>
<p><code><span class="comment">The following is related to "Variables" section as potential values in assignment.</span>undefined</code> 值在布尔类型环境中会被当作 <code>false</code> 。例如，下面的代码将会执行函数 <code>myFunction</code>，因为数组 <code>myArray</code> 中的元素未被赋值：</p>
<pre><code  class="language-javascript">var myArray = [];
if (!myArray[0])   myFunction(); 
</code></pre>
<p>数值类型环境中 <code>undefined</code> 值会被转换为 <code>NaN</code>。</p>
<pre><code  class="language-javascript">var a;
a + 2;    // 计算为 NaN
</code></pre>
<p>当你对一个 <code>null</code> 变量求值时，空值 <code>null</code> 在数值类型环境中会被当作0来对待，而布尔类型环境中会被当作 <code>false</code>。例如：</p>
<pre><code  class="language-javascript">var n = null;
console.log(n * 32); // 在控制台中会显示 0
</code></pre>
<h3 id="变量的作用域">变量的作用域</h3>
<p>在函数之外声明的变量，叫做<em>全局</em>变量，因为它可被当前文档中的任何其他代码所访问。在函数内部声明的变量，叫做<em>局部</em>变量，因为它只能在当前函数的内部访问。</p>
<p>ECMAScript 6 之前的 JavaScript 没有 <a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Guide/Statements#Block_Statement">语句块</a> 作用域；相反，语句块中声明的变量将成为语句块所在函数（或全局作用域）的局部变量。例如，如下的代码将在控制台输出 5，因为 <code>x</code> 的作用域是声明了 <code>x</code> 的那个函数（或全局范围），而不是 <code>if</code> 语句块。</p>
<pre><code  class="language-javascript">if (true) {
  var x = 5;
}
console.log(x); // 5
</code></pre>
<p>如果使用 ECMAScript 6 中的 <code>let</code> 声明，上述行为将发生变化。</p>
<pre><code  class="language-javascript">if (true) {
  let y = 5;
}
console.log(y); // ReferenceError: y 没有被声明</code></pre>
<h3 id="变量提升">变量提升</h3>
<p>JavaScript 变量的另一个不同寻常的地方是，你可以先使用变量稍后再声明变量而不会引发异常。这一概念称为变量提升；JavaScript 变量感觉上是被“提升”或移到了函数或语句的最前面。但是，提升后的变量将返回 <span style="font-family: courier new,andale mono,monospace;">undefined</span> 值。因此在使用或引用某个变量之后进行声明和初始化操作，这个被提升的变量仍将返回 undefined 值。</p>
<pre><code  class="language-javascript">/**
 * 例子1
 */
console.log(x === undefined); // true
var x = 3;


/**
 * 例子2
 */
// will return a value of undefined
var myvar = "my value";

(function() {
  console.log(myvar); // undefined
  var myvar = "local value";
})();
</code></pre>
<p>上面的例子，也可写作：</p>
<pre><code  class="language-javascript">/**
 * 例子1
 */
var x;
console.log(x === undefined); // true
x = 3;
 
/**
 * 例子2
 */
var myvar = "my value";
 
(function() {
  var myvar;
  console.log(myvar); // undefined
  myvar = "local value";
})();</code></pre>
<p>由于存在变量提升，一个函数中所有的<code>var</code>语句应尽可能地放在接近函数顶部的地方。这个习惯将大大提升代码的清晰度。</p>
<p>在 ECMAScript 6 中，let（const）将<strong>不会提升</strong>变量到代码块的顶部。因此，在变量声明之前引用这个变量，将抛出引用错误（ReferenceError）。这个变量将从代码块一开始的时候就处在一个“暂时性死区”，直到这个变量被声明为止。</p>
<pre><code  class="language-javascript">console.log(x); // ReferenceError
let x = 3;</code></pre>
<h3 id="函数提升">函数提升</h3>
<p>对于函数来说，只有函数声明会被提升到顶部，而函数表达式不会被提升。</p>
<pre><code  class="language-javascript">/* 函数声明 */

foo(); // "bar"

function foo() {
  console.log("bar");
}


/* 函数表达式 */

baz(); // 类型错误：baz 不是一个函数

var baz = function() {
  console.log("bar2");
};</code></pre>
<h3 id="全局变量">全局变量</h3>
<p><span class="comment">need links to pages discussing scope chains and the global object</span> 实际上，全局变量是<em>全局对象</em>的属性。在网页中，（译注：缺省的）全局对象是 <code>window</code> ，所以你可以用形如 <code>window.</code><em><code>variable</code> </em>的语法来设置和访问全局变量。</p>
<p>因此，你可以通过指定 window 或 frame 的名字，在当前 window 或 frame 访问另一个 window 或 frame 中声明的变量。例如，在文档里声明一个叫 <code>phoneNumber</code> 的变量，那么你就可以在子框架里使用 <code>parent.phoneNumber</code> 的方式来引用它。</p>
<h3 id="常量(Constants)">常量(Constants)</h3>
<p>你可以用关键字 <code>const</code> 创建一个只读的常量。常量标识符的命名规则和变量相同：必须以字母、下划线（_）或美元符号（$）开头并可以包含有字母、数字或下划线。</p>
<pre><code  class="language-javascript">const PI = 3.14;
</code></pre>
<p>常量不可以通过重新赋值改变其值，也不可以在代码运行时重新声明。它必须被初始化为某个值。</p>
<p>常量的作用域规则与 <code>let</code> 块级作用域变量相同。若省略<code>const</code>关键字，则该标识符将被视为变量。</p>
<p>在同一作用域中，不能使用与变量名或函数名相同的名字来命名常量。例如：</p>
<pre><code  class="language-javascript">// 这会造成错误
function f() {};
const f = 5;

// 这也会造成错误
function f() {
  const g = 5;
  var g;

  //语句
}
</code></pre>
<p>然而，对象属性被赋值为常量是不受保护的，所以下面的语句执行时不会产生错误。</p>
<pre><code  class="language-javascript">const MY_OBJECT = {"key": "value"};
MY_OBJECT.key = "otherValue";</code></pre>
<p>同样的，数组的被定义为常量也是不受保护的，所以下面的语句执行时也不会产生错误。</p>
<pre><code  class="language-javascript">const MY_ARRAY = ['HTML','CSS'];
MY_ARRAY.push('JAVASCRIPT');
console.log(MY_ARRAY); //logs ['HTML','CSS','JAVASCRIPT'];
</code></pre>
<h2 id="数据结构和类型">数据结构和类型</h2>
<h3 id="数据类型">数据类型</h3>
<p>最新的 ECMAScript 标准定义了7种数据类型：</p>
<ul>
<li>六种基本数据类型:
  <ul>
<li>布尔值（Boolean），有2个值分别是：<code>true</code> 和 <code>false</code>.</li>
<li>null ， 一个表明 null 值的特殊关键字。 JavaScript 是大小写敏感的，因此 <code>null</code> 与 <code>Null</code>、<code>NULL</code>或变体完全不同。</li>
<li>undefined ，和 null 一样是一个特殊的关键字，undefined 表示变量未定义时的属性。</li>
<li>数字（Number），整数或浮点数，例如： <code>42</code> 或者 <code>3.14159</code>。</li>
<li>字符串（String），字符串是一串表示文本值的字符序列，例如："Howdy" 。</li>
<li>代表（Symbol） ( 在 ECMAScript 6 中新添加的类型).。一种实例是唯一且不可改变的数据类型。</li>
</ul>
</li>
<li>以及对象（Object）。</li>
</ul>
<p>虽然这些数据类型相对来说比较少，但是通过他们你可以在程序中开发有用的功能。对象（<a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Global_Objects/Object" title="zh-CN/docs/JavaScript/Reference/Global Objects/Object">Objects</a>）和函数（<a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Global_Objects/Function" title="zh-CN/docs/JavaScript/Reference/Global Objects/Function">functions</a>）是这门语言的另外两个基本元素。你可以把对象当作存放值的一个命名容器，然后将函数当作你的程序能够执行的步骤。</p>
<h3 id="数据类型的转换">数据类型的转换</h3>
<p>JavaScript是一种动态类型语言(dynamically typed language)。这意味着你在声明变量时可以不必指定数据类型，而数据类型会在代码执行时会根据需要自动转换。因此，你可以按照如下方式来定义变量：</p>
<pre><code  class="language-javascript">var answer = 42;
</code></pre>
<p>然后，你还可以给同一个变量赋予一个字符串值，例如：</p>
<pre><code  class="language-javascript">answer = "Thanks for all the fish...";</code></pre>
<p>因为 JavaScript 是动态类型的，这种赋值方式并不会提示出错。</p>
<p>在包含的数字和字符串的表达式中使用加法运算符（+），JavaScript 会把数字转换成字符串。例如，观察以下语句：</p>
<pre><code  class="language-javascript">x = "The answer is " + 42 // "The answer is 42"
y = 42 + " is the answer" // "42 is the answer"
</code></pre>
<p>在涉及其它运算符（译注：如下面的减号'-'）时，JavaScript语言不会把数字变为字符串。例如（译注：第一例是数学运算，第二例是字符串运算）：</p>
<pre><code  class="language-javascript">"37" - 7 // 30
"37" + 7 // "377"
</code></pre>
<h3 id="字符串转换为数字">字符串转换为数字</h3>
<p>有一些方法可以将内存中表示一个数字的字符串转换为对应的数字。</p>
<h4 id="parseInt()和parseFloat()"><code>parseInt()</code>和<code>parseFloat()</code></h4>
<p>参见：<code><a class="new" href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Global_Objects/parseInt" rel="nofollow" title="zh-CN/docs/JavaScript/Reference/Global Objects/parseInt">parseInt()</a></code>和<code><a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Global_Objects/parseFloat" title="zh-CN/docs/JavaScript/Reference/Global Objects/parseFloat">parseFloat()</a></code>的相关页面。</p>
<p><code> parseInt </code>方法只能返回整数，所以使用它会丢失小数部分。另外，调用 parseInt 时最好总是带上进制(radix) 参数，这个参数用于指定使用哪一种进制。</p>
<p>将字符串转换为数字的另一种方法是使用一元<strong>加法运算符</strong>。</p>
<pre><code  class="language-javascript">"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   
// 注意：加入括号为清楚起见，不是必需的。
</code></pre>
<h2 id="字面量_(Literals)">字面量 (Literals)</h2>
<p>（译注：字面量是由语法表达式定义的常量；或，通过由一定字词组成的语词表达式定义的常量）</p>
<p>在JavaScript中，你可以使用各种字面量。这些字面量是脚本中按字面意思给出的固定的值，而不是变量。（译注：字面量是常量，其值是固定的，而且在程序脚本运行中不可更改，比如<em>false</em>，3.1415，thisIsStringOfHelloworld<em> </em>，invokedFunction: myFunction("myArgument")。本节将介绍以下类型的字面量：</p>
<ul>
<li><a href="#数组字面量(Array_literals)">数组字面量(Array literals)</a></li>
<li><a href="#布尔字面量(Boolean_literals)">布尔字面量(Boolean literals)</a></li>
<li><a href="#浮点数字面量(Floating-point_literals)">浮点数字面量(Floating-point literals)</a></li>
<li><a href="#整数(Integers)">整数(Integers)</a></li>
<li><a href="#对象字面量(Object_literals)">对象字面量(Object literals)</a></li>
<li><a href="#RegExp_literals">RegExp literals</a></li>
<li><a href="#字符串字面量(String_literals)">字符串字面量(String literals)</a></li>
</ul>
<h3 id="数组字面量_(Array_literals)">数组字面量 (Array literals)</h3>
<p>数组字面值是一个封闭在方括号对([])中的包含有零个或多个表达式的列表，其中每个表达式代表数组的一个元素。当你使用数组字面值创建一个数组时，该数组将会以指定的值作为其元素进行初始化，而其长度被设定为元素的个数。</p>
<p>下面的示例用3个元素生成数组<code>coffees</code>，它的长度是3。</p>
<pre><code  class="language-javascript">var coffees = ["French Roast", "Colombian", "Kona"];

var a=[3];

console.log(a.length); // 1

console.log(a[0]); // 3</code></pre>
<div class="note">
<p><strong>注意</strong><strong> </strong>这里的数组字面值也是一种对象初始化器。参考<a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Guide/Working_with_Objects#Using_Object_Initializers" title="zh-CN/docs/JavaScript/Guide/Working with Objects#Using Object Initializers">对象初始化器的使用</a>。</p>
</div>
<p>若在顶层（全局）脚本里用字面值创建数组，JavaScript语言将会在每次对包含该数组字面值的表达式求值时解释该数组。另一方面，在函数中使用的数组，将在每次调用函数时都会被创建一次。</p>
<p>数组字面值同时也是数组对象。有关数组对象的详情请参见<a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Guide/Predefined_Core_Objects#Array_Object">数组对象</a>一文。</p>
<h4 id="数组字面值中的多余逗号">数组字面值中的多余逗号</h4>
<p>（译注：声明时）你不必列举数组字面值中的所有元素。若你在同一行中连写两个逗号（,），数组中就会产生一个没有被指定的元素，其初始值是<code>undefined</code>。以下示例创建了一个名为<code>fish</code>的数组：</p>
<pre><code  class="language-javascript">var fish = ["Lion", , "Angel"];
</code></pre>
<p>在这个数组中，有两个已被赋值的元素，和一个空元素（fish[0]是"Lion"，fish[1]是undefined，而fish[2]是"Angel"；译注：此时数组的长度属性fish.length是3)。</p>
<p>如果你在元素列表的尾部添加了一个逗号，它将会被忽略。在下面的例子中，数组的长度是3，并不存在myList[3]这个元素（译注：这是指数组的第4个元素噢，作者是在帮大家复习数组元素的排序命名方法）。元素列表中其它所有的逗号都表示一个新元素（的开始）。</p>
<div class="note">
<p><strong>注意：</strong>尾部的逗号在早期版本的浏览器中会产生错误，因而编程时的最佳实践方式就是移除它们。</p>
</div>
<p>(译注：而“现代”的浏览器似乎鼓励这种方式，这也很好解释原因。尾部逗号可以减少向数组的最后添加元素时，因为忘记为这最后一个元素加逗号 所造成的错误。)</p>
<pre><code  class="language-javascript">var myList = ['home', , 'school', ];
</code></pre>
<p>在下面的例子中，数组的长度是4，元素<code>myList[0]</code>和<code>myList[2]</code>缺失（译注：没被赋值，因而是undefined）。</p>
<pre><code  class="language-javascript">var myList = [ , 'home', , 'school'];
</code></pre>
<p>再看一个例子。在这里，该数组的长度是4，元素<code>myList[1]</code>和<code>myList[3]</code>被漏掉了。（但是）只有最后的那个逗号被忽略。</p>
<pre><code  class="language-javascript">var myList = ['home', , 'school', , ];
</code></pre>
<p>理解多余的逗号（在脚本运行时会被如何处理）的含义，对于从语言层面理解JavaScript是十分重要的。但是，在你自己写代码时：<strong>显式地将缺失的元素声明为<code>undefined</code>，将大大提高你的代码的清晰度和可维护性</strong>。</p>
<h3 id="布尔字面量_(Boolean_literals)">布尔字面量 (Boolean literals)</h3>
<p>（译注：即逻辑字面量）</p>
<p>布尔类型有两种字面量：<code>true</code>和<code>false</code>。</p>
<p>不要混淆作为布尔对象的真和假与布尔类型的原始值true和false。<span class="short_text" id="result_box" lang="zh-CN"><span>布尔对象是原始</span><span>布尔</span><span>数据类型的一个包装器</span><span>。参见</span></span><span class="short_text" id="result_box" lang="zh-CN"><span><a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Guide/Predefined_Core_Objects#Boolean_Object" title="zh-CN/docs/JavaScript/Guide/Predefined Core Objects#Boolean Object"> 布尔对象</a>。</span></span></p>
<h3 id="整数_(Integers)">整数 (Integers)</h3>
<p>（译注：原文如此，没写成“整数字面量”，这里指的是整数字面量。）</p>
<p>整数可以用十进制（基数为10）、十六进制（基数为16）、八进制（基数为8）以及二进制（基数为2）表示。</p>
<ul>
<li><span class="short_text" id="result_box" lang="zh-CN"><span>十进制整数字面量由一串数字序列组成</span><span>，且没有前缀</span><span>0</span><span>。</span></span></li>
<li><span class="short_text" id="result_box" lang="zh-CN"><span>八进制的整数以 0（或</span></span>0O、0o）开头，<span class="short_text" lang="zh-CN"><span>只能包括</span><span>数字0-7</span><span>。</span></span></li>
<li><span class="short_text" id="result_box" lang="zh-CN"><span>十六进制整数以0x（或0X）开头，</span><span>可以包含</span><span>数字（0-9）</span><span>和</span><span>字母 a~f 或 A~</span><span>F</span><span>。</span></span></li>
<li><span class="short_text" id="result_box" lang="zh-CN"><span>二进制整数以0b（或0B）开头，只能包含数字</span><span>0和1。</span></span></li>
</ul>
<p>严格模式下，八进制整数字面量必须以0o或0O开头，而不能以0开头。</p>
<p>整数字面量举例：</p>
<pre><code>0, 117 and -345 (十进制, 基数为10)
015, 0001 and -0o77 (八进制, 基数为8) 
0x1123, 0x00111 and -0xF1A7 (十六进制, 基数为16或"hex")
0b11, 0b0011 and -0b11 (二进制, 基数为2)</code></code></pre>
<h3 id="浮点数字面量_(Floating-point_literals)">浮点数字面量 (Floating-point literals)</h3>
<p>浮点数字面值可以有以下的组成部分：</p>
<ul>
<li><span class="short_text" id="result_box" lang="zh-CN"><span>一个十进制</span><span>整数，可以</span><span>带正负号（</span><span>即前缀</span><span class="atn">“+”</span><span class="atn">或“ - ”</span><span>）</span><span>，</span></span></li>
<li>小数点（“.”），</li>
<li>小数部分（由一串十进制数表示），</li>
<li>指数部分。</li>
</ul>
<p>指数部分以“e”或“E”开头，后面跟着一个整数，可以有正负号（即前缀“+”或“-”）。浮点数字面量至少有一位数字，而且必须带小数点或者“e”（大写“E”也可）。</p>
<p>简言之，其语法是：</p>
<pre><code  class="language-javascript"><code class="language-html">[(+|-)][digits][.digits][(E|e)[(+|-)]digits]</code></code></pre>
<p>例如：</p>
<pre><code  class="language-javascript">3.14      
-.2345789 // -0.23456789
-3.12e+12  // -3.12*10<sup>12</sup>
.1e-23    // 0.1*10<sup>-23</sup>=10<sup>-24</sup>=1e-24
</code></pre>
<h3 id="对象字面量_(Object_literals)">对象字面量 (Object literals)</h3>
<p>对象字面值是封闭在花括号对({})中的一个对象的零个或多个"属性名-值"对的（元素）列表。你不能在一条语句的开头就使用对象字面值，这将导致错误或产生超出预料的行为， 因为此时左花括号（{）会被认为是一个语句块的起始符号。（译者：这 里需要对语句statement、块block等基本名词的解释）</p>
<p>以下是一个对象字面值的例子。对象car的第一个元素（译注：即一个属性/值对）定义了属性myCar；第二个元素，属性getCar，引用了一个函数（即CarTypes("Honda")）；第三个元素，属性special，使用了一个已有的变量（即Sales）。</p>
<pre><code  class="language-javascript">var Sales = "Toyota";

function CarTypes(name) {
  return (name === "Honda") ?
    name :
    "Sorry, we don't sell " + name + "." ;
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota 
</code></pre>
<p>更进一步的，你可以使用数字或字符串字面值作为属性的名字，或者在另一个字面值内嵌套上一个字面值。如下的示例中使用了这些可选项。</p>
<pre><code  class="language-javascript">var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda
</code></pre>
<p>对象属性名字可以是任意字符串，包括空串。如果对象属性名字不是合法的javascript标识符，它必须用""包裹。属性的名字不合法，那么便不能用.访问属性值，而是通过类数组标记("[]")访问和赋值。</p>
<pre><code  class="language-javascript">var unusualPropertyNames = {
  "": "An empty string",
  "!": "Bang!"
}
console.log(unusualPropertyNames."");   // 语法错误: Unexpected string
console.log(unusualPropertyNames[""]);  // An empty string
console.log(unusualPropertyNames.!);    // 语法错误: Unexpected token !
console.log(unusualPropertyNames["!"]); // Bang!</code></pre>
<p> </p>
<h4 id="增强的对象字面量_(Enhanced_Object_literals)">增强的对象字面量 (Enhanced Object literals)</h4>
<p>在ES2015，对象字面值扩展支持在创建时设置原型，简写了 foo: foo 形式的属性赋值，方法定义，支持父方法调用，以及使用表达式动态计算属性名。总之，这些也使对象字面值和类声明更加紧密地联系起来，让基于对象的设计从这些便利中更加受益。</p>
<pre><code  class="language-javascript"><code class="language-js"><span class="keyword token">var</span> obj <span class="operator token">=</span> <span class="punctuation token">{</span>
    <span class="comment token">// __proto__</span>
    __proto__<span class="punctuation token">:</span> theProtoObj<span class="punctuation token">,</span>
    <span class="comment token">// Shorthand for ‘handler: handler’</span>
    handler<span class="punctuation token">,</span>
    <span class="comment token">// Methods</span>
    <span class="function token">toString</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
     <span class="comment token">// Super calls</span>
     <span class="keyword token">return</span> <span class="string token">"d "</span> <span class="operator token">+</span> <span class="keyword token">super</span><span class="punctuation token">.</span><span class="function token">toString</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
    <span class="punctuation token">}</span><span class="punctuation token">,</span>
    <span class="comment token">// Computed (dynamic) property names</span>
    <span class="punctuation token">[</span> <span class="string token">'prop_'</span> <span class="operator token">+</span> <span class="punctuation token">(</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">=</span><span class="operator token">&gt;</span> <span class="number token">42</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">]</span><span class="punctuation token">:</span> <span class="number token">42</span>
<span class="punctuation token">}</span><span class="punctuation token">;</span></code></code></pre>
<p>请注意：</p>
<pre><code  class="language-javascript">var foo = {a: "alpha", 2: "two"};
console.log(foo.a);    // alpha
console.log(foo[2]);   // two
//console.log(foo.2);  // SyntaxError: missing ) after argument list
//console.log(foo[a]); // ReferenceError: a is not defined
console.log(foo["a"]); // alpha
console.log(foo["2"]); // two</code></pre>
<h3 id="RegExp_字面值">RegExp 字面值</h3>
<p>一个正则表达式是字符被斜线（译注：正斜杠“/”）围成的表达式。下面是一个正则表达式文字的一个例子。</p>
<pre><code  class="language-javascript"><code class="language-js"><span class="keyword token">var</span> re <span class="operator token">=</span> <span class="regex token">/ab+c/</span><span class="punctuation token">;</span></code></code></pre>
<h3 id="字符串字面量_(String_literals)">字符串字面量 (String literals)</h3>
<p>字符串字面量是由双引号（"）对或单引号（'）括起来的零个或多个字符。字符串被限定在同种引号之间；也即，必须是成对单引号或成对双引号。下面的例子都是字符串字面值：</p>
<pre><code  class="language-javascript">"foo"
'bar'
"1234"
"one line \n another line"
"John's cat"</code></pre>
<p>你可以在字符串字面值上使用字符串对象的所有方法——JavaScript会自动将字符串字面值转换为一个临时字符串对象，调用该方法，然后废弃掉那个临时的字符串对象。你也能用对字符串字面值使用类似String.length的属性：</p>
<pre><code  class="language-javascript"><code>console.log("John's cat".length) 
// 将打印字符串中的字符个数（包括空格） 
// 结果为：10</code></code></pre>
<p>在ES2015中，还提供了一种模板字符串（template literals），模板字符串提供了一些语法糖来帮你构造字符串。这与Perl、Python还有其他语言中的字符串插值（string interpolation）的特性非常相似。除此之外，你可以在通过模板字符串前添加一个tag来自定义模板字符串的解析过程，这可以用来防止注入攻击，或者用来建立基于字符串的高级数据抽象。</p>
<pre><code  class="language-javascript">// Basic literal string creation
`In JavaScript '\n' is a line-feed.`

// Multiline strings
`In JavaScript this is
 not legal.`

// String interpolation
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// Construct an HTTP request prefix is used to interpret the replacements and construction
POST`http://foo.org/bar?a=${a}&amp;b=${b}
     Content-Type: application/json
     X-Credentials: ${credentials}
     { "foo": ${foo},
       "bar": ${bar}}`(myOnReadyStateChangeHandler);
</code></pre>
<p>除非有特别需要使用字符串对象，否则,你应当始终使用字符串字面值。要查看字符串对象的有关细节，请参见<a href="https://developer.mozilla.org/zh-CN/docs/JavaScript/Guide/Predefined_Core_Objects#String_Object" title="zh-CN/docs/JavaScript/Guide/Predefined Core Objects#String Object">字符串对象</a>。</p>
<h4 id="在字符串中使用的特殊字符">在字符串中使用的特殊字符</h4>
<p>作为一般字符的扩展，你可以在字符串中使用特殊字符，如下例所示。</p>
<pre><code  class="language-javascript">"one line \n another line"
</code></pre>
<p>以下表格列举了你能在JavaScript的字符串中使用的特殊字符。</p>
<table class="standard-table">
<caption>表 2.1 JavaScript 特殊字符</caption>
<thead>
<tr>
<th scope="col">字符</th>
<th scope="col">意思</th>
</tr>
</thead>
<tbody>
<tr>
<td>\0</td>
<td>Null字节</td>
</tr>
<tr>
<td>\b</td>
<td>退格符</td>
</tr>
<tr>
<td>\f</td>
<td>换页符</td>
</tr>
<tr>
<td>\n</td>
<td>换行符</td>
</tr>
<tr>
<td>\r</td>
<td>回车符</td>
</tr>
<tr>
<td>\t</td>
<td>Tab (制表符)</td>
</tr>
<tr>
<td>\v</td>
<td>垂直制表符</td>
</tr>
<tr>
<td>\'</td>
<td>单引号</td>
</tr>
<tr>
<td>\"</td>
<td>双引号</td>
</tr>
<tr>
<td>\\</td>
<td>反斜杠字符（\）</td>
</tr>
<tr>
<td>\<em>XXX</em></td>
<td>由从0到377最多三位八进制数<em>XXX</em>表示的 Latin-1 字符。例如，\251是版权符号的八进制序列。</td>
</tr>
<tr>
<td>\x<em>XX</em></td>
<td>由从00和FF的两位十六进制数字XX表示的Latin-1字符。例如，\ xA9是版权符号的十六进制序列。</td>
</tr>
<tr>
<td><em>\uXXXX</em></td>
<td>由四位十六进制数字XXXX表示的Unicode字符。例如，\ u00A9是版权符号的Unicode序列。见<a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">Unicode escape sequences</a> (Unicode 转义字符).</td>
</tr>
<tr>
<td>\u<em>{XXXXX}</em></td>
<td>Unicode代码点 (code point) 转义字符。例如，\u{2F804} 相当于Unicode转义字符 \uD87E\uDC04的简写。</td>
</tr>
</tbody>
</table>
<p>译注：严格模式下，不能使用八进制转义字符。</p>
<h4 id="转义字符">转义字符</h4>
<p>对于那些未出现在表2.1中的字符，其所带的前导反斜线'\'将被忽略。但是，这一用法已被废弃，应当避免使用。</p>
<p>通过在引号前加上反斜线'\'，可以在字符串中插入引号，这就是<em>引号转义</em>。例如:</p>
<pre><code  class="language-javascript">var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
console.log(quote);
</code></pre>
<p>代码的运行结果为:</p>
<pre><code  class="language-javascript">He read "The Cremation of Sam McGee" by R.W. Service.
</code></pre>
<p>要在字符串中插入'\'字面值，必须转义反斜线。例如，要把文件路径 c:\temp 赋值给一个字符串，可以采用如下方式:</p>
<pre><code  class="language-javascript">var home = "c:\\temp";
</code></pre>
<p>也可以在换行之前加上反斜线以转义换行（译注：实际上就是一条语句拆成多行书写），这样反斜线和换行都不会出现在字符串的值中。</p>
<pre><code  class="language-javascript">var str = "this string \
is broken \
across multiple\
lines."
<span class="objectBox objectBox-text">console.log(str);</span>   // <span class="objectBox objectBox-text">this string is broken across multiplelines.</span>
</code></pre>
<p>Javascript没有“heredoc”语法，但可以用行末的换行符转义和转义的换行来近似实现 </p>
<pre><code  class="language-javascript">var poem = 
"Roses are red,\n\
Violets are blue.\n\
Sugar is sweet,\n\
and so is foo."
</code></pre>
<p>ECMAScript 2015 增加了一种新的字面量，叫做模板字面量 <strong><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings" rel="noreferrer">template literals</a>。</strong>它包含一些新特征，包括了多行字符串！</p>
<pre><code  class="language-javascript">var poem =
`Roses are red,
Violets are blue.
Sugar is sweet,
and so is foo.`</code></pre>
<p> </p>
<h2 id="更多信息">更多信息</h2>
<p>?本章重点包括声明和类型的基本语法。学习更多关于的JavaScript语言，可参见本站以下章节：</p>
<ul>
<li><a href="Guide/Control_flow_and_error_handling">流程控制与错误处理</a></li>
<li><a href="Guide/Loops_and_iteration">循环与迭代</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions">?函数</a><a href="Guide/Functions">函数</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators">?</a><a href="Guide/Expressions_and_Operators">表达式与运算符</a></li>
</ul>
<p>下一章，流程控制与错误处理</p>
<p></p><div class="prevnext" style="text-align: right;">
<p><a href="Guide/Introduction" style="float: left;">« 上一页</a><a href="Guide/Control_flow_and_error_handling">下一页  »</a></p>
</div><p></p>
</article>